package com.leetcode.hashtable;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @author: ZhouBert
 * @date: 2019/9/28
 * @description: 290. 单词规律
 * A
 * 给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。
 * <p>
 * 这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。
 * <p>
 * 示例1:
 * 输入: pattern = "abba", str = "dog cat cat dog"
 * 输出: true
 * 示例 2:
 * 输入:pattern = "abba", str = "dog cat cat fish"
 * 输出: false
 * 示例 3:
 * 输入: pattern = "aaaa", str = "dog cat cat dog"
 * 输出: false
 * 示例 4:
 * 输入: pattern = "abba", str = "dog dog dog dog"
 * 输出: false
 * 说明:
 * 你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。    
 * <p>
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/word-pattern
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */
public class WordPattern290 {

	/**
	 * todo:2 ms	35.6 MB
	 * 使用两个 hashMap 完成映射关系
	 * @param pattern
	 * @param str
	 * @return
	 */
	public static boolean wordPattern(String pattern, String str) {
		if (str == null || str.length() == 0 || pattern == null || pattern.length() == 0) {
			return false;
		}


		char[] paChars = pattern.toCharArray();
		///将 pattern 归到同一个标准
		Map<Character, Character> temp2 = new LinkedHashMap<>();
		int index2 = 0;
		for (Character item :
				paChars) {
			if (!temp2.containsKey(item)) {
				temp2.put(item,(char) ((int) 'a' + index2++));
			}
		}

		///1.将 str 映射
		String[] strings = str.split(" ");
		if(strings.length!=pattern.length()){
			return false;
		}
		Map<Character, String> temp = new LinkedHashMap<>();
		int index = 0;
		for (String item :
				strings) {
			if (!temp.containsValue(item)) {
				temp.put((char) ((int) 'a' + index++), item);
			}
		}

		String tempStr = "";
		for (Character item :
				paChars) {

			if (!temp.containsKey(temp2.get(item))){
				return false;
			}
			tempStr += temp.get(temp2.get(item)) + " ";
		}
		if (str.equals(tempStr.trim())){
			return true;
		}
		return false;
	}

	/**
	 * todo:C 的思路如何用 java 表达出来？？
	 * 分析例子，总结规律：
	 * 1，str与pattern数量相同
	 * 2，拆解出一个str单词时，若该单词在str已经出现，则该单词对应的pattern字符必须是曾经对应的pattern字符
	 * 3，拆解出一个str单词时，若该单词在str未出现，则该单词对应的pattern字符必须未出现
	 * 很明显这是一种及其强烈的映射关系，本题我们考虑str----pattern的映射
	 * 算法思路：str=“dog cat cat *” pattern=“abb？”
	 * 1，设置单词str到pattern'的哈希映射，使用数组used[128]记录pattern字符是否使用
	 * 2，遍历str，按照空格拆分单词，同时对应移动pattern的指针，判断如果该单词从未出现在哈希表：
	 *         如果pattern的used使用了，false
	 *         否则当前单词与pattern作映射，并且used标记
	 *     否则
	 *         如果当前哈希表单词映射不是指向pattern字符，false
	 * 3，str pattern数量不匹配 false
	 * 总体说：就是同时遍历两个集合，未出现作映射，都出现过作判断，全部遍历后看数量。
	 * @param pattern
	 * @param str
	 * @return
	 */
	public static boolean wordPatternOnLesson(String pattern, String str){
		return false;

	}

	public static void main(String[] args) {
		String pattern = "abba", str = "dog cat cat dog";
		pattern = "aaaa";
		str = "dog cat cat dog";

		pattern = "abba";
		str = "dog cat cat dog";

		pattern = "e";
		str = "eukera";

		pattern = "deadbeef";
		str = "d e a d b e e f";
		System.out.println(wordPattern(pattern, str));
	}
}
